Enumerating descendants of SystemCallError, subclassing them, and including Trilogy::Error seems like the most straightforward approach so far, but is admittedly not pretty.

So:

Errno.constants.map { |c| Errno.const_get(c) }.select { |c| c.is_a?(Class) && c < SystemCallError }.

Is the proper way to do it I think. The only issue is:

>> Errno.constants.map { |c| Errno.const_get(c) }.select { |c| c.is_a?(Class) && c < SystemCallError }.size
=> 158

And the vast majority of them will never happen.

Alternatively, we can do it manually for a subset of ernno we care about, and have a fallback Trilogy::UnexpectedSyscallError for the ones we don't expect to happen aside from weird bugs.

Alternatively, we can do it manually for a subset of ernno we care about, and have a fallback Trilogy::UnexpectedSyscallError for the ones we don't expect to happen aside from weird bugs.

I'm not super confident identifying which errnos seem reasonable to care about, so as long as we're sticking to the module-based approach my vote would be to enumerate all of them. If there are more that we truly expect, maybe we should promote them to proper classes?

cc @matthewd any opinions here?

Yeah my concern is that it's really hard to define a list of plausibly-expectable errors (e.g. EHOSTUNREACH probably wouldn't make an initial cut, but considered properly does seem like a thing that an interested caller could reasonably want to specifically handle as a connection issue -> retry / whatever).

Not to mention the theoretical variation across platforms once we stray from the basics.

My first thought was to use a lazy hash... which doesn't feel like a particularly good idea, and would be messy though maybe not ridiculous. It's a bounded list, and most processes most of the time won't ever see / need most classes.

This feels terrible but I can't see an alternative that doesn't pre-encode a subset of errnos that are "allowed" to happen. 😕

Oh actually lazy hash sounds like a good idea? e.g. something like this right?

  class SyscallError
    ERRORS = {}
    class << self
      def from_errno(errno, message)
        ERRORS.fetch(errno) do |errno|
          errno_name = Errno.constants.find { |c| Errno.const_get(c)::Errno == errno }
          errno_subclass = Class.new(Errno.const_get(errno_name)) { include Trilogy::Error }
          ERRORS[errno] = const_set(errno_name, errno_subclass)
        end.new(message)
      end
    end
  end

That way we avoid subclassing the unlikely ones. A bit messy, but not any worse than iterating all of em IMO 😅

I'd advise against dynamic const_set. Until very recently (3.2) that bumps the global constant cache, which isn't good.

It also make it weird because you can't reference the error before it's actually raised.

That said, defining the 150-ish classes would use about 30kB, it's a indeed a bit much... but acceptable?

>> ObjectSpace.memsize_of(Class.new(StandardError)) * 154
=> 29568

Until very recently (3.2) that bumps the global constant cache

Oh good to know, thank you Jean 🙇‍♀️

That said, defining the 150-ish classes would use about 30kB

I think it would be closer to 20kbB; several of the Errno constants map to Errno::NOERROR. With #uniq:

>> Errno.constants.map { |c| Errno.const_get(c) }.uniq.select { |c| c.is_a?(Class) && c < SystemCallError }.size
=> 107
>> ObjectSpace.memsize_of(Class.new(StandardError)) * 107
=> 20544

@byroot @matthewd do we feel comfortable shipping this in its current form?

Fine by me.

I think @casperisfine was advising against the combo of const_set + deferred subclassing, not necessarily const_set + immediate-subclass loop.

Failing that, I think we'd want to define both self.inspect and inspect:

Class.new(Errno::EBADF).new
=> #<#<Class:0x0000000104db7e50>: Bad file descriptor>

not necessarily const_set + immediate-subclass loop.

Yeah, if it's eagerly defined it's fine.

Ahh gotcha, yeah that makes more sense in terms of invalidating the global constant cache. Let me bring back back the const_set then 👍